from math import floor
import pandas as pd
from buffUtils import *
from skillUtils import *
from attrUtils import *

计入技能释放 = ["天风汲雨", "血影留痕", "天绝地灭", "图穷匕见", "暴雨梨花针", "连弩（鬼斧）", "连弩", "蚀肌弹",
          "天女散花", "孔雀翎", "重弩（鬼斧）"]

循环场景表 = {

    "起手爆发": {
        "技能数": {
            "天风汲雨": 23,
            "血影留痕": 27,
            "天绝地灭": 24,
            "化血（DOT）": 25,
            "图穷匕见": 3,
            "暴雨梨花针": 10,
            "连弩（鬼斧）": 12,
            "连弩": 0,
            "破": 2,
            "蚀肌弹": 1,
            "天女散花": 2,
            "孔雀翎": 1,
            "重弩（鬼斧）": 0,
            "重弩": 0,
            "罡风镖法": 7
        },
        "时间": 15,
    },
    "战斗中爆发": {
        "技能数": {
            "天风汲雨": 24,
            "血影留痕": 28,
            "天绝地灭": 25,
            "化血（DOT）": 25,
            "图穷匕见": 3,
            "暴雨梨花针": 10,
            "连弩（鬼斧）": 12,
            "连弩": 0,
            "破": 2,
            "蚀肌弹": 1,
            "天女散花": 2,
            "孔雀翎": 1,
            "重弩（鬼斧）": 0,
            "重弩": 0,
            "罡风镖法": 7
        },
        "时间": 15,
    },

    "常态循环": {
        "技能数": {
            "天风汲雨": 32,
            "血影留痕": 59,
            "天绝地灭": 35,
            "化血（DOT）": 64,
            "图穷匕见": 24,
            "暴雨梨花针": 50,
            "连弩（鬼斧）": 3,
            "连弩": 49,
            "破": 9,
            "蚀肌弹": 12,
            "天女散花": 4,
            "孔雀翎": 4,
            "重弩（鬼斧）": 0,
            "重弩": 1,
            "罡风镖法": 51
        },
        "时间": 83,
    },

    "结尾循环": {
        "技能数": {
            "天风汲雨": 17,
            "血影留痕": 27,
            "天绝地灭": 18,
            "化血（DOT）": 16,
            "图穷匕见": 9,
            "暴雨梨花针": 20,
            "连弩（鬼斧）": 3,
            "连弩": 20,
            "破": 4,
            "蚀肌弹": 7,
            "天女散花": 2,
            "孔雀翎": 1,
            "重弩（鬼斧）": 0,
            "重弩": 0,
            "罡风镖法": 20
        },
        "时间": 32,
    }
}


def 计算技能总数(技能数: dict) -> float:
    count = 0.0
    for key, value in 技能数.items():
        if key in 计入技能释放:
            count = count + value
    return count


def 套装覆盖率计算(t: float) -> float:
    return 1 - (0.9 ** (6 / t))


def 曙色覆盖率计算(最终面板会心: float) -> float:
    会心 = min(最终面板会心, 1)
    return 1 - ((1 - 会心) ** 2)


def 伤腰覆盖率计算(t: float) -> float:
    return 8 / (30 + 5 * t)


def 伤鞋触发时间(最终面板会心: float, t: float) -> float:
    会心 = min(最终面板会心, 1)
    return 10 + 1 / 会心 * t


def 伤腕触发时间(t: float) -> float:
    return 10 + 10 * t


def 心无弩心覆盖率计算(最终面板会心: float) -> float:
    会心 = min(最终面板会心, 1)
    return 1 - ((1 - 会心) ** (6 / 1.25))


def 常态弩心覆盖率计算(最终面板会心: float) -> float:
    会心 = min(最终面板会心, 1)
    return 1 - ((1 - 会心) ** (6 / 1.5))


def 杀机天绝给连弩增伤覆盖率(循环场景: str, 循环时间: float) -> float:
    if 循环场景 == "起手爆发":
        天绝覆盖时间 = 15
        # 前为天绝数，后为覆盖秒数
        天绝平均覆盖 = (3 * 4 + 5 * 6 + 4 * 1 + 2 * 4) / 天绝覆盖时间
        return 天绝平均覆盖 * (天绝覆盖时间 / 循环时间)
    elif 循环场景 == "战斗中爆发":
        天绝覆盖时间 = 15
        # 前为天绝数，后为覆盖秒数
        天绝平均覆盖 = (4 * 4 + 5 * 6 + 4 * 1 + 2 * 4) / 天绝覆盖时间
        return 天绝平均覆盖 * (天绝覆盖时间 / 循环时间)
    elif 循环场景 == "常态循环":
        # 前为天绝数，后为覆盖秒数
        天绝17 = 3 * 10
        天绝21 = 3 * 10 + 2 * 3
        天绝29 = 4 * 10 + 3 * 3
        天绝覆盖时间 = 10 + 10 + 10 + 3 + 3
        天绝平均覆盖 = (天绝17 + 天绝21 + 天绝29) / 天绝覆盖时间
        return 天绝平均覆盖 * (天绝覆盖时间 / 循环时间)
    elif 循环场景 == "结尾循环":
        天绝覆盖时间 = 19
        # 前为天绝数，后为覆盖秒数
        天绝35 = 3 * 8 + 3 * 9 + 2 * 2
        天绝平均覆盖 = 天绝35 / 天绝覆盖时间
        return 天绝平均覆盖 * (天绝覆盖时间 / 循环时间)
    return 0


def 方法_构造技能常态增益列表(装备增益情况: dict) -> dict:
    skillPersistentBuffDicts = {
        "蚀肌弹": [
            蚀肌弹秘籍()
        ],
        "暴雨梨花针": [
            暴雨梨花针秘籍(),
            # 套装暴雨加成(),
            流星赶月(),
        ],
        "天绝地灭": [
            天绝地灭秘籍(),
            # 套装天绝加成(),
            杀机断魂天绝增伤(3)
        ],
        "图穷匕见": [
            图穷匕见秘籍(),
            杀机断魂暗藏增伤(1)
        ],
    }
    if "套装技能加成" in 装备增益情况["套装"]:
        skillPersistentBuffDicts["暴雨梨花针"].append(套装暴雨加成())
        skillPersistentBuffDicts["天绝地灭"].append(套装天绝加成())
    return skillPersistentBuffDicts


def 循环伤害计算(循环场景: str, 总属性: dict, 技能系数表: dict, 装备增益情况: dict, 实战增益表: dict) -> dict:
    # ---------- 计算需要 ----------
    整体属性表 = 总属性.copy()
    时间 = 循环场景表[循环场景]["时间"]
    技能数 = 循环场景表[循环场景]["技能数"]
    t = 时间 / 计算技能总数(技能数)
    skillPersistentBuffDicts = 方法_构造技能常态增益列表(装备增益情况)

    # ---------- 增益添加 ----------
    # 注意，对同一数值的加算应在乘算前
    # 常驻增益添加
    添加面板增益(整体属性表, 秋风加成())
    # 考虑到气魄的特殊性，在实战增益之前添加，实战中仅需将”元气“的加成乘以1.1即可。
    添加面板增益(整体属性表, 气魄加成(整体属性表["元气"]))
    # 水特效武器
    水特效武器数值 = 装备增益情况.get("水特效", 0)
    添加面板增益(整体属性表, 水灭虚加成(水特效武器数值))
    # print(整体属性表)

    风特效腰坠数值 = 装备增益情况.get("风特效", 0)
    if 循环场景 == "起手爆发":
        添加面板增益(整体属性表, 风灭虚加成(风特效腰坠数值), 1)
    elif 循环场景 == "战斗中爆发":
        添加面板增益(整体属性表, 风灭虚加成(风特效腰坠数值), 0.5)
    # 这里放实战增益添加
    方法_分析实战增益并添加(实战增益表, 整体属性表)
    # 套装神力
    if "套装神力加成" in 装备增益情况["套装"]:
        添加面板增益(整体属性表, 套装神力加成(), 套装覆盖率计算(t))
    # 擘两分星 - 神机80以下
    擘两分星全局覆盖率 = 0.5879 - 0.0279
    添加技能增益(整体属性表, 擘两分星80以下加成(), 擘两分星全局覆盖率)
    # 伤腰大附魔
    if 装备增益情况.get("腰带大附魔", False):
        添加技能增益(整体属性表, 腰带大附魔加成("期望"), 伤腰覆盖率计算(t))
        伤腰覆盖率 = 伤腰覆盖率计算(t)
    else:
        伤腰覆盖率 = 0

    if 循环场景 == "起手爆发" or 循环场景 == "战斗中爆发":
        # 心无
        添加面板增益(整体属性表, 心无加成(), 1)
        # 鬼斧
        添加面板增益(整体属性表, 杨威加成(整体属性表["基础攻击"]), 1)
        添加面板增益(整体属性表, 弩心加成(整体属性表["毒性内功破防数值"]), 心无弩心覆盖率计算(整体属性表["外功会心"]))
    else:
        添加面板增益(整体属性表, 弩心加成(整体属性表["毒性内功破防数值"]), 常态弩心覆盖率计算(整体属性表["外功会心"]))

    伤害表 = dict()
    伤害表["时间"] = 时间

    # ---------- 计算开始 ----------
    # 天风汲雨
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["天风汲雨"])
    # temp.update(技能系数表["天风汲雨"])
    常驻技能BUFF字典 = skillPersistentBuffDicts.get("天绝地灭", "none")
    for buff字典 in 常驻技能BUFF字典:
        添加技能增益(temp, buff字典, 1)
    添加技能增益(temp, 擘两分星20以上加成(temp["攻击系数"]), 0.9805)
    添加技能增益(temp, 擘两分星80以下加成(), 0.05)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["天风汲雨"] * (
            字典最终伤害计算("天风汲雨", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "天风汲雨", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    # print(temp1)
    # print("天风伤害：%f, 均值：%f" % (tempDamage, (tempDamage / 技能数["天风汲雨"])))
    伤害表["天风汲雨"] = dict()
    伤害表["天风汲雨"]["伤害"] = tempDamage
    伤害表["天风汲雨"]["总次数"] = 技能数["天风汲雨"]
    伤害表["天风汲雨"]["会心次数"] = temp["外功会心"] * 技能数["天风汲雨"]

    # 天绝地灭
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["天绝地灭"])
    常驻技能BUFF字典 = skillPersistentBuffDicts.get("天绝地灭", "none")
    for buff字典 in 常驻技能BUFF字典:
        添加技能增益(temp, buff字典)
    添加技能增益(temp, 擘两分星20以上加成(temp["攻击系数"]), 0.9605)
    添加技能增益(temp, 擘两分星80以下加成(), 0.05)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["天绝地灭"] * (
            字典最终伤害计算("天绝地灭", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "天绝地灭", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["天绝地灭"] = dict()
    伤害表["天绝地灭"]["伤害"] = tempDamage
    伤害表["天绝地灭"]["总次数"] = 技能数["天绝地灭"]
    伤害表["天绝地灭"]["会心次数"] = temp["外功会心"] * 技能数["天绝地灭"]

    # 血影留痕（天绝触发）
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["血影留痕"])
    添加技能增益(temp, 杀机断魂天绝增伤(3), 1)
    添加技能增益(temp, 擘两分星80以下加成(), 0.05)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["天绝地灭"] * (
            字典最终伤害计算("血影留痕", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "血影留痕", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["血影留痕"] = dict()
    伤害表["血影留痕"]["伤害"] = tempDamage
    伤害表["血影留痕"]["总次数"] = 技能数["天绝地灭"]
    伤害表["血影留痕"]["会心次数"] = temp["外功会心"] * 技能数["天绝地灭"]

    # 图穷匕见
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["图穷匕见"])
    常驻技能BUFF字典 = skillPersistentBuffDicts.get("图穷匕见", "none")
    for buff字典 in 常驻技能BUFF字典:
        添加技能增益(temp, buff字典)
    temp.update(添加技能增益(temp, 擘两分星20以上加成(temp["攻击系数"]), 0.9605))
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["图穷匕见"] * (
            字典最终伤害计算("图穷匕见", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "图穷匕见", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["图穷匕见"] = dict()
    伤害表["图穷匕见"]["伤害"] = tempDamage
    伤害表["图穷匕见"]["总次数"] = 技能数["图穷匕见"]
    伤害表["图穷匕见"]["会心次数"] = temp["外功会心"] * 技能数["图穷匕见"]

    # 血影留痕（图穷匕见触发）
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["血影留痕"])
    添加技能增益(temp, 杀机断魂暗藏增伤(1), 1)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["图穷匕见"] * (
            字典最终伤害计算("血影留痕", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "血影留痕", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["血影留痕"]["伤害"] = 伤害表["血影留痕"]["伤害"] + tempDamage
    伤害表["血影留痕"]["总次数"] = 伤害表["血影留痕"]["总次数"] + 技能数["图穷匕见"]
    伤害表["血影留痕"]["会心次数"] = 伤害表["血影留痕"]["会心次数"] + temp["外功会心"] * 技能数["图穷匕见"]

    # 化血（DOT）
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["化血（DOT）"])
    # 化血吃分星快照
    添加技能增益(temp, 擘两分星80以下加成(), 0.3)
    # 化血曙色催寒全覆盖
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["化血（DOT）"] * 字典最终伤害计算("化血（DOT）", temp1, "期望")
    伤害表["化血（DOT）"] = dict()
    伤害表["化血（DOT）"]["伤害"] = tempDamage
    伤害表["化血（DOT）"]["总次数"] = 技能数["化血（DOT）"]
    伤害表["化血（DOT）"]["会心次数"] = temp["外功会心"] * 技能数["化血（DOT）"]

    # 暴雨梨花针
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["暴雨梨花针"])
    常驻技能BUFF字典 = skillPersistentBuffDicts.get("暴雨梨花针", "none")
    for buff字典 in 常驻技能BUFF字典:
        添加技能增益(temp, buff字典)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["暴雨梨花针"] * (字典最终伤害计算("暴雨梨花针", temp, "期望") * (
            1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("暴雨梨花针", temp1, "期望") * 曙色覆盖率计算(
        temp1["外功会心"]))
    伤害表["暴雨梨花针"] = dict()
    伤害表["暴雨梨花针"]["伤害"] = tempDamage
    伤害表["暴雨梨花针"]["总次数"] = 技能数["暴雨梨花针"]
    伤害表["暴雨梨花针"]["会心次数"] = temp["外功会心"] * 技能数["暴雨梨花针"]

    # 连弩（鬼斧）
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["连弩（鬼斧）"])
    # 这里要加一个杀机对千机变的增益
    添加面板增益(temp, 杀机断魂连弩增伤(杀机天绝给连弩增伤覆盖率(循环场景, 时间)), 1)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["连弩（鬼斧）"] * (字典最终伤害计算("连弩（鬼斧）", temp, "期望") * (
            1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("连弩（鬼斧）", temp1, "期望") * (曙色覆盖率计算(
        temp1["外功会心"])))
    伤害表["连弩（鬼斧）"] = dict()
    伤害表["连弩（鬼斧）"]["伤害"] = tempDamage
    伤害表["连弩（鬼斧）"]["总次数"] = 技能数["连弩（鬼斧）"]
    伤害表["连弩（鬼斧）"]["会心次数"] = temp["外功会心"] * 技能数["连弩（鬼斧）"]

    # 连弩
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["连弩"])
    # 这里要加一个杀机对千机变的增益
    添加面板增益(temp, 杀机断魂连弩增伤(杀机天绝给连弩增伤覆盖率(循环场景, 时间)), 1)
    # print(杀机断魂连弩增伤(杀机天绝给连弩增伤覆盖率(循环场景, 时间)))
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["连弩"] * (
            字典最终伤害计算("连弩", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "连弩", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    # if 技能数["连弩"] != 0:
    #     print("连弩伤害：%f, 均值：%f" % (tempDamage, (tempDamage / 技能数["连弩"])))
    #     print(temp)
    伤害表["连弩"] = dict()
    伤害表["连弩"]["伤害"] = tempDamage
    伤害表["连弩"]["总次数"] = 技能数["连弩"]
    伤害表["连弩"]["会心次数"] = temp["外功会心"] * 技能数["连弩"]

    # 破
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["破"])
    # 吃千机变的增益
    添加面板增益(temp, 杀机断魂连弩增伤(杀机天绝给连弩增伤覆盖率(循环场景, 时间)), 1)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["破"] * (字典最终伤害计算("破", temp, "期望") *
                             (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("破", temp1,
                                                                    "期望") * 曙色覆盖率计算(
                temp1["外功会心"]))
    伤害表["破"] = dict()
    伤害表["破"]["伤害"] = tempDamage
    伤害表["破"]["总次数"] = 技能数["破"]
    伤害表["破"]["会心次数"] = temp["外功会心"] * 技能数["破"]

    # 蚀肌弹
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["蚀肌弹"])
    常驻技能BUFF字典 = skillPersistentBuffDicts.get("蚀肌弹", "none")
    for buff字典 in 常驻技能BUFF字典:
        添加技能增益(temp, buff字典)
    添加技能增益(temp, 擘两分星80以下加成(), -0.2)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["蚀肌弹"] * (
            字典最终伤害计算("蚀肌弹", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "蚀肌弹", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["蚀肌弹"] = dict()
    伤害表["蚀肌弹"]["伤害"] = tempDamage
    伤害表["蚀肌弹"]["总次数"] = 技能数["蚀肌弹"]
    伤害表["蚀肌弹"]["会心次数"] = temp["外功会心"] * 技能数["蚀肌弹"]

    # 天女散花
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["天女散花"])
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["天女散花"] * (
            字典最终伤害计算("天女散花", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "天女散花", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["天女散花"] = dict()
    伤害表["天女散花"]["伤害"] = tempDamage
    伤害表["天女散花"]["总次数"] = 技能数["天女散花"]
    伤害表["天女散花"]["会心次数"] = temp["外功会心"] * 技能数["天女散花"]

    # 伤腕
    if 装备增益情况.get("护腕大附魔", False):
        temp = 整体属性表.copy()
        方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["昆吾 · 弦刃"])
        # 曙色催寒
        temp1 = temp.copy()
        添加面板增益(temp1, 催寒加成(), 1)
        伤腕次数 = 时间 / 伤腕触发时间(t)
        tempDamage = 伤腕次数 * (字典最终伤害计算("昆吾 · 弦刃", temp, "期望") * (
                1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("昆吾 · 弦刃", temp1, "期望") * 曙色覆盖率计算(
            temp1["外功会心"]))
        # if 伤腕次数 != 0:
        #     print("昆吾 · 弦刃伤害：%f, 均值：%f" % (tempDamage, (tempDamage / floor(时间 / 伤腕触发时间(t)))))
        #     print(temp)
        伤害表["昆吾 · 弦刃"] = dict()
        伤害表["昆吾 · 弦刃"]["伤害"] = tempDamage
        伤害表["昆吾 · 弦刃"]["总次数"] = 伤腕次数
        伤害表["昆吾 · 弦刃"]["会心次数"] = temp["外功会心"] * 伤腕次数

    # 伤鞋
    if 装备增益情况.get("鞋子大附魔", False):
        temp = 整体属性表.copy()
        方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["刃凌"])
        # 曙色催寒
        temp1 = temp.copy()
        添加面板增益(temp1, 催寒加成(), 1)
        伤鞋次数 = 时间 / 伤鞋触发时间(temp['外功会心'], t)
        tempDamage = 伤鞋次数 * (字典最终伤害计算("刃凌", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
            "刃凌", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
        伤害表["刃凌"] = dict()
        伤害表["刃凌"]["伤害"] = tempDamage
        伤害表["刃凌"]["总次数"] = 伤鞋次数
        伤害表["刃凌"]["会心次数"] = temp["外功会心"] * 伤鞋次数

    # 孔雀翎
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["孔雀翎"])
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["孔雀翎"] * (
            字典最终伤害计算("孔雀翎", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "孔雀翎", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["孔雀翎"] = dict()
    伤害表["孔雀翎"]["伤害"] = tempDamage
    伤害表["孔雀翎"]["总次数"] = 技能数["孔雀翎"]
    伤害表["孔雀翎"]["会心次数"] = temp["外功会心"] * 技能数["孔雀翎"]

    # 罡风镖法
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["罡风镖法"])
    # 罡风不吃内功伤害加成
    添加技能增益(temp, 擘两分星80以下加成(), -擘两分星全局覆盖率)
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["罡风镖法"] * (
            字典最终伤害计算("罡风镖法", temp, "期望") * (1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算(
        "罡风镖法", temp1, "期望") * 曙色覆盖率计算(temp1["外功会心"]))
    伤害表["罡风镖法"] = dict()
    伤害表["罡风镖法"]["伤害"] = tempDamage
    伤害表["罡风镖法"]["总次数"] = 技能数["罡风镖法"]
    伤害表["罡风镖法"]["会心次数"] = temp["外功会心"] * 技能数["罡风镖法"]

    # 重弩（鬼斧）
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["重弩（鬼斧）"])
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["重弩（鬼斧）"] * (字典最终伤害计算("重弩（鬼斧）", temp, "期望") * (
            1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("重弩（鬼斧）", temp1, "期望") * 曙色覆盖率计算(
        temp1["外功会心"]))
    伤害表["重弩（鬼斧）"] = dict()
    伤害表["重弩（鬼斧）"]["伤害"] = tempDamage
    伤害表["重弩（鬼斧）"]["总次数"] = 技能数["重弩（鬼斧）"]
    伤害表["重弩（鬼斧）"]["会心次数"] = temp["外功会心"] * 技能数["重弩（鬼斧）"]

    # 重弩
    temp = 整体属性表.copy()
    方法_技能嵌入总面板(总面板=temp, 技能系数表=技能系数表["重弩"])
    # 曙色催寒
    temp1 = temp.copy()
    添加面板增益(temp1, 催寒加成(), 1)
    tempDamage = 技能数["重弩"] * (字典最终伤害计算("重弩", temp, "期望") * (
            1 - 曙色覆盖率计算(temp["外功会心"])) + 字典最终伤害计算("重弩", temp1, "期望") * 曙色覆盖率计算(
        temp1["外功会心"]))
    伤害表["重弩"] = dict()
    伤害表["重弩"]["伤害"] = tempDamage
    伤害表["重弩"]["总次数"] = 技能数["重弩"]
    伤害表["重弩"]["会心次数"] = temp["外功会心"] * 技能数["重弩"]

    return 伤害表


def 技能数据最终处理(技能数据: dict, 总伤害: float) -> dict:
    for key, value in 技能数据.items():
        伤害占比 = value["伤害"] / 总伤害 * 100
        if value["总次数"] == 0:
            会心率 = 0
        else:
            会心率 = value["会心次数"] / value["总次数"] * 100
        技能数据[key]["伤害占比"] = "%.1f %%" % 伤害占比
        技能数据[key]["会心率"] = "%.1f %%" % 会心率
        技能数据[key]["会心次数"] = floor(技能数据[key]["会心次数"])
        技能数据[key]["总次数"] = floor(技能数据[key]["总次数"])
        技能数据[key]["伤害"] = floor(技能数据[key]["伤害"])
    # 对'技能数据'中的子字典按照伤害值进行排序
    sorted_skills = sorted(技能数据.items(), key=lambda x: x[1]['伤害'], reverse=True)

    # 将排序后的结果重新构建成字典
    sorted_skill_data = dict(sorted_skills)

    # 将排序后的技能数据重新放回原始数据字典中
    return sorted_skill_data


def 木桩伤害计算(循环伤害表集合: list) -> dict:
    最终伤害表 = dict()
    最终伤害表["技能数据"] = dict()
    最终伤害表["时间"] = 0
    总伤害 = 0
    for 循环伤害表 in 循环伤害表集合:
        for key, value in 循环伤害表.items():
            # print(key, value)
            if key == "时间":
                最终伤害表["时间"] = 最终伤害表["时间"] + value
            else:
                temp = 最终伤害表["技能数据"].get(key, "none")
                总伤害 = 总伤害 + value["伤害"]
                # print(key, value)
                if temp != "none":
                    最终伤害表["技能数据"][key]["伤害"] = 最终伤害表["技能数据"][key]["伤害"] + value["伤害"]
                    最终伤害表["技能数据"][key]["总次数"] = 最终伤害表["技能数据"][key]["总次数"] + value["总次数"]
                    最终伤害表["技能数据"][key]["会心次数"] = 最终伤害表["技能数据"][key]["会心次数"] + value["会心次数"]
                else:
                    最终伤害表["技能数据"][key] = value
    最终伤害表["技能数据"] = 技能数据最终处理(最终伤害表["技能数据"], 总伤害)
    最终伤害表["DPS"] = floor(总伤害 / 最终伤害表["时间"])
    return 最终伤害表


def 倒模计算(心法属性: dict, 目标属性: dict, 技能系数表: dict, 面板属性: dict, 装备增益情况: dict, 实战增益表: dict) -> dict:
    总属性 = dict()
    总属性.update(心法属性)
    总属性.update(目标属性)
    总属性.update(面板属性)
    总属性.update(技能系数表["空表"])
    return 木桩伤害计算([
        循环伤害计算("起手爆发", 总属性, 技能系数表, 装备增益情况, 实战增益表),
        循环伤害计算("常态循环", 总属性, 技能系数表, 装备增益情况, 实战增益表),
        循环伤害计算("战斗中爆发", 总属性, 技能系数表, 装备增益情况, 实战增益表),
        循环伤害计算("常态循环", 总属性, 技能系数表, 装备增益情况, 实战增益表),
        循环伤害计算("战斗中爆发", 总属性, 技能系数表, 装备增益情况, 实战增益表),
        循环伤害计算("结尾循环", 总属性, 技能系数表, 装备增益情况, 实战增益表),
    ])


def 输出计算结果(result: dict):
    for key, value in result["技能数据"].items():
        # print(key, value)
        # formatted_output = f"{key:<12} - 次数：{value['总次数']:>3}  伤害：{floor(value['伤害']):>9,}  会心率：{value['会心率']:>6}  伤害占比：{value['伤害占比']:>5}"
        # print(formatted_output)
        # print(adjusted_width(key, 25) + adjusted_width(str(value["总次数"]), 10) + adjusted_width(str(floor(value["伤害"])),15) + adjusted_width(value["会心率"], 10) + adjusted_width(value["伤害占比"], 10))
        print("  %-15s次数：%-10d伤害：%-15d会心率：%-15s伤害占比：%-15s" % (
            key, value["总次数"], floor(value["伤害"]), value["会心率"], value["伤害占比"]))
    print("战斗时间：%d 秒  |  DPS：%d" % (result["时间"], result["DPS"]))


def 属性收益分析(初始DPS: int, 同分属性数值: dict, 心法属性: dict, 目标属性: dict, 技能系数表: dict, 面板属性: dict, 装备增益情况: dict, 实战增益表: dict) -> dict:
    result = {}
    最大收益数值 = -1
    for 属性字段名, 属性数值 in 同分属性数值.items():
        面板快照 = 面板属性.copy()
        if 属性字段名 == "元气":
            提升面板 = {
                "元气": 属性数值,
                "基础攻击": 0.18 * 属性数值,
                "毒性内功破防数值": 0.3 * 属性数值,
                "最终毒性内功破防数值": 0.3 * 属性数值,
                "毒性内功破防": 计算会心或破防百分比(0.3 * 属性数值),
                "最终攻击": 0.18 * 属性数值 + 1.75 * 属性数值,
                "外功会心数值": 0.57 * 属性数值,
                "外功会心": 计算会心或破防百分比(0.57 * 属性数值),
            }
        elif 属性字段名 == "基础攻击":
            提升面板 = {
                "基础攻击": 属性数值,
                "最终攻击": 属性数值,
            }
        elif 属性字段名 == "毒性内功破防数值":
            提升面板 = {
                "毒性内功破防数值": 属性数值,
                "最终毒性内功破防数值": 属性数值
            }
        else:
            提升面板 = {
                属性字段名: 属性数值
            }
        添加面板增益(面板快照, 提升面板, 1)
        带百分比面板 = 基于面板数值计算百分比(面板快照)
        收益数值 = 倒模计算(心法属性, 目标属性, 技能系数表, 带百分比面板, 装备增益情况, 实战增益表)["DPS"] - 初始DPS
        最大收益数值 = max(收益数值, 最大收益数值)
        result[属性字段名] = 收益数值
    for key, value in result.items():
        result[key] = "%.2f%%" % round(value / 最大收益数值 * 100, 4)
    return result


def 输出属性收益(属性收益表: dict) -> dict:
    sorted_dict = {k: v for k, v in sorted(属性收益表.items(), key=lambda item: float(item[1].strip('%')), reverse=True)}
    mapping = {
        "外功会效数值": "会效",
        "外功会心数值": "会心",
        "毒性内功破防数值": "破防",
        "元气": "元气",
        "基础攻击": "基础攻击",
        "无双数值": "无双",
        "破招": "破招"
    }
    for key, value in sorted_dict.items():
        print("%s: %s" % (mapping[key], value), end="  |  ")
    print()


def 方法_分析元气力道根骨加成并添加(总属性: dict, 属性名: str, 数值: float) -> dict:
    if 属性名 == "元气":
        # 在气魄之后添加，额外加上气魄的数值
        数值 = 数值 * 0.01953 * 5 + 数值
        总属性["元气"] += 数值
        总属性["毒性内功破防数值"] += 0.3 * 数值
        总属性["最终毒性内功破防数值"] += 0.3 * 数值
        总属性["毒性内功破防"] += round(计算会心或破防百分比(0.3 * 数值), 4)
        总属性["基础攻击"] += 0.18 * 数值
        总属性["最终攻击"] += 0.18 * 数值 + 1.75 * 数值
        总属性["外功会心数值"] += 0.57 * 数值
        总属性["外功会心"] += round(计算会心或破防百分比(0.57 * 数值), 4)
    elif 属性名 == "身法":
        总属性["外功会心数值"] += 0.64 * 数值
        总属性["外功会心"] += round(计算会心或破防百分比(0.64 * 数值), 4)
    elif 属性名 == "力道":
        总属性["外功破防数值"] += 0.3 * 数值
        总属性["最终外功破防数值"] += 0.3 * 数值
        总属性["外功破防"] += round(计算会心或破防百分比(0.3 * 数值), 4)
        总属性["外功基础攻击"] += 0.15 * 数值
        总属性["外功最终攻击"] += 0.15 * 数值


def 方法_分析实战增益并添加(实战增益表: dict, 总属性: dict) -> dict:
    if 实战增益表:
        row = 实战增益表.copy()

        方法_分析元气力道根骨加成并添加(总属性, "元气", row["元气"])
        方法_分析元气力道根骨加成并添加(总属性, "力道", row["力道"])
        方法_分析元气力道根骨加成并添加(总属性, "身法", row["身法"])

        总属性["无视防御A"] += row["无视防御A"]
        总属性["无视防御B"] += row["无视防御B"]
        总属性["目标易伤"] += row["目标易伤"]
        总属性["本体增伤"] += row["本体增伤"]

        总属性["基础攻击"] += row["基础攻击"]
        总属性["最终攻击"] += (row["基础攻击"] + row["百分比攻击"] * 总属性["基础攻击"])

        总属性["外功会心"] += row["外功会心"]
        总属性["外功会效"] += row["外功会效"]

        总属性["毒性内功破防数值"] += row["毒性内功破防"]
        总属性["最终毒性内功破防数值"] += row["毒性内功破防"] + row["百分比破防"] * 总属性["毒性内功破防数值"]
        总属性["毒性内功破防"] = round(计算会心或破防百分比(总属性["最终毒性内功破防数值"]), 4)

        总属性["无双数值"] += row["无双"]
        总属性["无双数值"] += row["百分比无双"] * 总属性["无双数值"]
        总属性["无双"] = round(计算无双百分比(总属性["无双数值"]), 4)

        总属性["破招"] += row["破招"]
        总属性["加速等级"] += row["加速"]
    # print(总属性)
    return 总属性
